编程范式游记（1）- 起源 [2026重制版]

┌─────────────────────────────────────────────┐
│           C语言的伟大之处                     │
│                                             │
│  ✅ "信任程序员"                             │
│     • 不阻止你做任何底层操作                  │
│     • 给予最大的自由度                        │
│                                             │
│  ✅ "保持最小和简单"                          │
│     • 语言核心只有约30个关键字                 │
│     • 没有隐藏的魔法                          │
│                                             │
│  ✅ "极致的性能"                              │
│     • 接近硬件的运行效率                      │
│     • 可预测的行为                            │
│                                             │
│  ✅ "可移植性"                                │
│     • 一次编写，到处编译                       │
│     • 从嵌入式到超级计算机                    │
└─────────────────────────────────────────────┘

// 只能用于int类型
void swap_int(int* x, int* y) {
    int tmp = *x;
    *x = *y;
    *y = tmp;
}
 
// 如果需要交换double呢？再写一个？
void swap_double(double* x, double* y) {
    double tmp = *x;
    *x = *y;
    *y = tmp;
}

// 泛型版本 - 使用void*
void swap(void* x, void* y, size_t size) {
    char tmp[size];          // VLA: 变长数组(C99)
    memcpy(tmp, y, size);   // 内存拷贝
    memcpy(y, x, size);
    memcpy(x, tmp, size);
}
 
// 使用示例
int a = 10, b = 20;
swap(&a, &b, sizeof(int));  // 必须手动传入size！
 
double c = 3.14, d = 2.71;
swap(&c, &d, sizeof(double));

// 宏版本的swap
#define SWAP(x, y, type) { \
    type _tmp = (x);       \
    (x) = (y);             \
    (y) = _tmp;            \
}
 
// 使用
SWAP(a, b, int);     // 展开为具体的代码
SWAP(c, d, double);   // 每种类型生成一份代码

// 泛型的search函数
int search(
    void* array,           // 数组起始地址
    size_t length,         // 数组长度
    void* target,          // 目标值
    size_t elem_size,      // 元素大小 ← 新增参数
    int (*cmp)(void*, void*) // 比较函数 ← 新增参数
) {
    for (size_t i = 0; i < length; i++) {
        void* elem = (char*)array + elem_size * i;  // 手动计算地址
        if (cmp(elem, target) == 0) {
            return (int)i;
        }
    }
    return -1;  // 未找到
}

# Python 3.12+ 类型推断示例
from typing import TypeVar
 
T = TypeVar('T')
 
def identity(x: T) -> T:
    """返回输入值本身"""
    return x
 
# 编译器/IDE能推断：
result1 = identity(42)        # result1 的类型被推断为 int
result2 = identity("hello")  # result2 的类型被推断为 str
result3 = identity([1,2,3])  # result3 的类型被推断为 list[int]
 
# Hindley-Milner 类型推断算法
# 这是函数式语言（ML, Haskell, OCaml, F#）的核心技术
# 也影响了 Rust 和 TypeScript 的类型系统

本系列文章安排：
├── 第01讲（本文）：起源 - C语言与泛型的困境
├── 第02讲：泛型编程 - C++模板与类型系统深入
├── 第03讲：类型系统和泛型的本质
├── 第04讲：函数式编程 - 纯函数与不可变性
├── 第05讲：修饰器模式 - Python/Go中的函数式实践
├── 第06讲：面向对象编程 - 类、继承与多态
├── 第07讲：基于原型的编程范式 - JavaScript/Self
├── 第08讲：Go语言的委托模式 - 组合优于继承
├── 第09讲：编程的本质 - 逻辑与控制的分离
├── 第10讲：逻辑编程范式 - Prolog入门
└── 第11讲：程序世界里的编程范式 - 总结与展望